{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EheA5_j_cEwc"
      },
      "source": [
        "##### Copyright 2020 Google LLC.\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YCriMWd-pRTP"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\"); { display-mode: \"form\" }\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvRwFTkqcp1e"
      },
      "source": [
        "# Swap curve fitting in TensorFlow Quant Finance (TFF)\n",
        "\n",
        "TensorFlow Finance has built-in library for unconstrained numerical optimization. This notebook shows how to use it.\n",
        "\n",
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uG8UAZXjeUhf"
      },
      "outputs": [],
      "source": [
        "#@title Install TF Quant Finance\n",
        "!pip install 'tensorflow>=2.1.0'\n",
        "!pip install tf-quant-finance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xmqzltQrwcDt"
      },
      "outputs": [],
      "source": [
        "#@title Imports\n",
        "from datetime import datetime\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_probability as tfp\n",
        "import functools\n",
        "import matplotlib.colors as colors\n",
        "\n",
        "import tf_quant_finance as tff\n",
        "import tf_quant_finance.datetime as dates\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "from IPython.core.pylabtools import figsize\n",
        "\n",
        "# Import seaborn if you want to have fancy visualization\n",
        "# import seaborn as sns\n",
        "# sns.set(style=\"darkgrid\")\n",
        "\n",
        "figsize(12, 8)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OV4HJAtryCYk"
      },
      "source": [
        "## Build instrument cashflows"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBnoZmn0yCYk"
      },
      "source": [
        "The following functions are used to build the cashflows on the fixed and floating legs for curve fitting."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-E8i05fuyCYl"
      },
      "source": [
        "### 1. Cash instruments\n",
        "\n",
        "Cash instruments generate the cashflow by simple spot rate, i.e.\n",
        "\n",
        "$$[1 + R \\cdot \\tau] \\cdot DF(\\tau) = 1$$\n",
        "\n",
        "where $\\tau$ is the tenor of the instrument, $R$ is the market rate and $DF(\\tau)$ is the discount factor at time $\\tau$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nxbPjiRXyCYl"
      },
      "outputs": [],
      "source": [
        "#@title 1. Cash instruments\n",
        "def build_spot_cash_instrument(tenor, close, dtype, **kwargs):\n",
        "    \"\"\"Build spot cash instrument.\n",
        "    \n",
        "    Args:\n",
        "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.     \n",
        "      close: `float64`. Defined the close rate of the instrument.\n",
        "        \n",
        "    Returns:\n",
        "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
        "      `float_leg_start_time`.\n",
        "    \"\"\"\n",
        "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
        "    tenor = tenor.quantity().numpy() / 12.0\n",
        "    return {\n",
        "        'float_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
        "        'float_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
        "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
        "        'fixed_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
        "        'fixed_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
        "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
        "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
        "        'pv': 0.0,\n",
        "        'initial_curve_rate': 1e-6,\n",
        "    }"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "za2sJdn8yCYl"
      },
      "source": [
        "### 2. Forward and Future instruments\n",
        "\n",
        "Forward instruments, similar to cash instruments, generate the cashflow by simple spot rate on a specified forward date, i.e.\n",
        "\n",
        "$$[1 + R \\cdot \\tau(t_1, t_2)] \\cdot DF(t_2) - DF(t_1) = 0$$\n",
        "\n",
        "where $t_1$ is the forward start time, $t_2$ is the maturity time, $\\tau(t_1, t_2)$ is the tenor of the instrument, and R is the market rate.\n",
        "\n",
        "The difference between the forward and future rates is the convexity adjustment. Since the difference is minimal for instrument less then 2Y maturity, it is assumed to be the same for simplicity here."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CntXRevLyCYm"
      },
      "outputs": [],
      "source": [
        "#@title 2. Forward and Future instruments\n",
        "def build_futures_instrument(        \n",
        "        settle_date, maturity_date, close, tenor, dtype, **kwargs):\n",
        "    \"\"\"Build futures instrument.\n",
        "    \n",
        "    Args:\n",
        "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
        "        is settled.\n",
        "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
        "        instrument.\n",
        "      close: `float64`. Defined the close rate of the instrument.\n",
        "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.       \n",
        "        \n",
        "    Returns:\n",
        "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
        "      `float_leg_start_time`.\n",
        "    \"\"\"\n",
        "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
        "    tenor = tenor.quantity().numpy() / 12.0\n",
        "    \n",
        "    start = daycount(\n",
        "        start_date=dates.dates_from_datetimes([settle_date]),\n",
        "        end_date=dates.dates_from_datetimes([maturity_date]),\n",
        "        dtype=dtype\n",
        "    )\n",
        "    \n",
        "    return {\n",
        "        'float_leg_start_time': start,\n",
        "        'float_leg_end_time': start + tenor,\n",
        "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
        "        'fixed_leg_start_time': start,\n",
        "        'fixed_leg_end_time': start + tenor,\n",
        "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
        "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
        "        'pv': 0.0,\n",
        "        'initial_curve_rate': 1e-6,\n",
        "    }    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rw0PzEHKyCYm"
      },
      "source": [
        "### 3. Swap instruments\n",
        "\n",
        "Given a pre-defined notional principal $K$, the present value of the fixed leg can be expressed as\n",
        "\n",
        "$$ PV(fixed) = \\sum_{i=1}^{N_{fixed}} [K \\cdot R \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{fixed}}) $$\n",
        "\n",
        "where $R$ is the market rate, $N_{fixed}$ is the total number of fixed leg payments, $\\tau(i)$ is the day count fraction that determines the $i^{th}$ payment amount, $DF(t_1)$ is the discount factor at $i^{th}$ payment time t. \n",
        "\n",
        "Same for the present value of the floating leg\n",
        "\n",
        "$$ PV(floating) = \\sum_{i=1}^{N_{floating}} [K \\cdot R(i) \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{floating}}) $$\n",
        "\n",
        "where $R(i)$ is an effective rate to cover $i^{th}$ payment on the floating leg.\n",
        "\n",
        "Under the no-arbitrage rule, the present value of the fixed and floating leg must be equal, i.e.\n",
        "\n",
        "$$ PV(fixed) = PV(floating) $$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6ZCJcmolyCYm"
      },
      "outputs": [],
      "source": [
        "#@title 3. Swap instruments\n",
        "def build_swap_instrument(\n",
        "        settle_date, maturity_date, close, fixed_tenor, float_tenor, daycount,\n",
        "        roll_convention, dtype, **kwargs):\n",
        "    \"\"\"Build futures instrument.\n",
        "    \n",
        "    Args:\n",
        "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
        "        is settled.\n",
        "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
        "        instrument.\n",
        "      close: `float64`. Defined the close rate of the instrument.\n",
        "      fixed_tenor: `float64`. Defined the tenor of the fixed rate.\n",
        "      float_tenor: `float64`. Defined the tenor of the floating rate.\n",
        "      daycount: `callable`. Defines the daycount convention function imported\n",
        "          from `dates.daycounts`.\n",
        "      roll_convention: `dates.BusinessDayConvention`. Defines the roll\n",
        "          convention.\n",
        "      dtype: `tf.Dtype`. If supplied the dtype for the (elements of)\n",
        "        `float_leg_start_times`, and `fixed_leg_start_times`.\n",
        "        Default value: None which maps to the default dtype inferred by\n",
        "        TensorFlow.   \n",
        "          \n",
        "    Returns:\n",
        "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
        "      `float_leg_start_time`.\n",
        "    \"\"\"    \n",
        "    settle_date = dates.dates_from_datetimes([settle_date])\n",
        "    maturity_date = dates.dates_from_datetimes([maturity_date])\n",
        "    float_leg_dates = dates.PeriodicSchedule(\n",
        "        start_date=settle_date,\n",
        "        end_date=maturity_date,\n",
        "        tenor=float_tenor,\n",
        "        roll_convention=roll_convention,\n",
        "        backward=False).dates()[0]  \n",
        "    fixed_leg_dates = dates.PeriodicSchedule(\n",
        "        start_date=settle_date,\n",
        "        end_date=maturity_date,\n",
        "        tenor=fixed_tenor,\n",
        "        roll_convention=roll_convention,\n",
        "        backward=False).dates()[0]          \n",
        "        \n",
        "    return {\n",
        "        'float_leg_start_time': daycount(\n",
        "            start_date=settle_date, \n",
        "            end_date=float_leg_dates[:-1],\n",
        "            dtype=dtype),\n",
        "        'float_leg_end_time': daycount(\n",
        "            start_date=settle_date, \n",
        "            end_date=float_leg_dates[1:],\n",
        "            dtype=dtype),\n",
        "        'float_leg_daycount': daycount(\n",
        "            start_date=float_leg_dates[:-1],\n",
        "            end_date=float_leg_dates[1:],\n",
        "            dtype=dtype),\n",
        "        'fixed_leg_start_time': daycount(\n",
        "            start_date=settle_date, \n",
        "            end_date=fixed_leg_dates[:-1],\n",
        "            dtype=dtype),\n",
        "        'fixed_leg_end_time': daycount(\n",
        "            start_date=settle_date, \n",
        "            end_date=fixed_leg_dates[1:],\n",
        "            dtype=dtype),\n",
        "        'fixed_leg_daycount': daycount(\n",
        "            start_date=fixed_leg_dates[:-1],\n",
        "            end_date=fixed_leg_dates[1:],\n",
        "            dtype=dtype),\n",
        "        'fixed_leg_cashflow': tf.repeat(\n",
        "            tf.constant(-close, dtype=dtype), \n",
        "            repeats=fixed_leg_dates.shape[0] - 1, \n",
        "        ),\n",
        "        'pv': 0.0,\n",
        "        'initial_curve_rate': 1e-6,\n",
        "    }"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HVH0aSkayCYn"
      },
      "source": [
        "## Fit the interest rate curve"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w_VD0S97yCYn"
      },
      "source": [
        "The data is retrieved from Bloomberg on 2020-02-14 to fit the USD LIBOR 3M curve. \n",
        "\n",
        "The following market instruments are used\n",
        "\n",
        "- LIBOR Fixed 3 Month: Spot LIBOR 3M rate\n",
        "\n",
        "- ED Futures: Eurodollar Futures with expiry up to 2Y\n",
        "\n",
        "- Interest Rate Swap: Liquid interest rate swap instruments with tenors from 2 years to 50 years"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p8qwbQb5yCYn"
      },
      "outputs": [],
      "source": [
        "float_leg_start_times = []\n",
        "float_leg_end_times = []\n",
        "float_leg_daycounts = []\n",
        "fixed_leg_start_times = []\n",
        "fixed_leg_end_times = []\n",
        "fixed_leg_daycounts = []\n",
        "fixed_leg_cashflows = []\n",
        "pvs = []\n",
        "initial_curve_rates = []\n",
        "\n",
        "# Global dtype\n",
        "dtype = tf.float64\n",
        "\n",
        "# Global daycount - Fit on USD curve\n",
        "daycount = dates.daycount_actual_360\n",
        "\n",
        "# Global roll convention - Backward\n",
        "roll_convention = dates.BusinessDayConvention.PRECEDING\n",
        "\n",
        "# The fixed leg payment frequency is 6M\n",
        "fixed_tenor = dates.periods.months(6)\n",
        "\n",
        "# The floating rate is always USD LIBOR 3M\n",
        "float_tenor = dates.periods.months(3)\n",
        "\n",
        "instruments = [\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2020-05-21', \n",
        "     'close': 0.01696000000, 'name': 'USD3MD'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2020-06-17', \n",
        "     'close': 0.01669900000, 'name': 'EDH0'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2020-09-16', \n",
        "     'close': 0.01544400000, 'name': 'EDM0'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2020-12-16', \n",
        "     'close': 0.01468600000, 'name': 'EDU0'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2021-03-17', \n",
        "     'close': 0.01427500000, 'name': 'EDZ0'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2021-06-16', \n",
        "     'close': 0.01326200000, 'name': 'EDH1'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2021-09-15', \n",
        "     'close': 0.01299700000, 'name': 'EDM1'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2021-12-15', \n",
        "     'close': 0.01277900000, 'name': 'EDU1'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2022-03-16', \n",
        "     'close': 0.01295900000, 'name': 'EDZ1'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2022-06-15', \n",
        "     'close': 0.01288600000, 'name': 'EDH2'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2022-09-21', \n",
        "     'close': 0.01295900000, 'name': 'EDM2'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2022-12-21', \n",
        "     'close': 0.01308200000, 'name': 'EDU2'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2023-03-15', \n",
        "     'close': 0.01335500000, 'name': 'EDZ2'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2024-02-21', \n",
        "     'close': 0.01378410000, 'name': 'USDAM3L4Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2025-02-21', \n",
        "     'close': 0.01384037500\n",
        "     , 'name': 'USDAM3L6Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2027-02-22', \n",
        "     'close': 0.01419340000, 'name': 'USDAM3L7Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2028-02-22', \n",
        "     'close': 0.01443062500, 'name': 'USDAM3L8Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2029-02-21', \n",
        "     'close': 0.01468025000, 'name': 'USDAM3L9Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2030-02-21', \n",
        "     'close': 0.01494412500, 'name': 'USDAM3L10Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2032-02-23', \n",
        "     'close': 0.01542162500, 'name': 'USDAM3L12Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2035-02-21', \n",
        "     'close': 0.01592825000, 'name': 'USDAM3L15Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2040-02-21', \n",
        "     'close': 0.01644683333, 'name': 'USDAM3L20Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2045-02-21', \n",
        "     'close': 0.01666350000, 'name': 'USDAM3L25Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2050-02-22', \n",
        "     'close': 0.01662650000, 'name': 'USDAM3L30Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2060-02-23', \n",
        "     'close': 0.01613000000, 'name': 'USDAM3L40Y'},\n",
        "    {'settle_date': '2020-02-19', 'maturity_date': '2070-02-21', \n",
        "     'close': 0.01534000000, 'name': 'USDAM3L50Y'},\n",
        "]\n",
        "\n",
        "for instrument in instruments:\n",
        "    instrument['settle_date'] = (\n",
        "        datetime.strptime(instrument['settle_date'], '%Y-%m-%d')\n",
        "    )\n",
        "    instrument['maturity_date'] = (\n",
        "        datetime.strptime(instrument['maturity_date'], '%Y-%m-%d')\n",
        "    )    \n",
        "    if instrument['name'] == 'USD3MD':\n",
        "        # Spot instrument\n",
        "        instrument = build_spot_cash_instrument(\n",
        "            tenor=float_tenor, \n",
        "            dtype=dtype,\n",
        "            **instrument\n",
        "        )\n",
        "    elif instrument['name'][:2] == 'ED':\n",
        "        # Futures instrument\n",
        "        instrument = build_futures_instrument(\n",
        "            dtype=dtype,\n",
        "            tenor=float_tenor, \n",
        "            **instrument\n",
        "        )\n",
        "    elif instrument['name'].startswith('USDAM3L'):\n",
        "        # Swap instrument\n",
        "        instrument = build_swap_instrument(\n",
        "            fixed_tenor=fixed_tenor,\n",
        "            float_tenor=float_tenor,\n",
        "            roll_convention=roll_convention,\n",
        "            daycount=daycount,\n",
        "            dtype=dtype,\n",
        "            **instrument\n",
        "        )\n",
        "    else:\n",
        "        raise NotImplementedError(\n",
        "            'Cannot recognize the type of instrument %s'\n",
        "            % instrument['name']\n",
        "        )\n",
        "    \n",
        "    float_leg_start_times.append(instrument['float_leg_start_time'])\n",
        "    float_leg_end_times.append(instrument['float_leg_end_time'])\n",
        "    float_leg_daycounts.append(instrument['float_leg_daycount'])\n",
        "    fixed_leg_start_times.append(instrument['fixed_leg_start_time'])\n",
        "    fixed_leg_end_times.append(instrument['fixed_leg_end_time'])\n",
        "    fixed_leg_daycounts.append(instrument['fixed_leg_daycount'])\n",
        "    fixed_leg_cashflows.append(instrument['fixed_leg_cashflow'])\n",
        "    pvs.append(instrument['pv'])\n",
        "    initial_curve_rates.append(instrument['initial_curve_rate'])\n",
        "    \n",
        "curve = tff.rates.swap_curve_fit(\n",
        "    float_leg_start_times=float_leg_start_times,\n",
        "    float_leg_end_times=float_leg_end_times,\n",
        "    float_leg_daycount_fractions=float_leg_daycounts,\n",
        "    fixed_leg_start_times=fixed_leg_start_times,\n",
        "    fixed_leg_end_times=fixed_leg_end_times,\n",
        "    fixed_leg_cashflows=fixed_leg_cashflows,\n",
        "    fixed_leg_daycount_fractions=fixed_leg_daycounts,\n",
        "    present_values=tf.constant(pvs, dtype=dtype),\n",
        "    initial_curve_rates=tf.constant(initial_curve_rates, dtype))    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "Vka2gRDOyCYo",
        "outputId": "8d8079c8-eec5-431d-c01a-f94864a556e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 544
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.plot(curve.times, curve.rates)\n",
        "plt.title('Discount Rate Curve', fontsize=20)\n",
        "plt.xlabel('Time', fontsize=18)\n",
        "plt.ylabel('Discount Rate', fontsize=18)\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aD2I681iyCYq"
      },
      "source": [
        "## Reference"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0iN3oMS0yCYq"
      },
      "source": [
        "[1] Bloomberg, Building the Bloomberg Interest Rate Curve – Definitions and Methodology, Mar 2016"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Swap Curve Fitting.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}